SherbyNet - /page/wikibook/entry.mu

Micron Document

<!DOCTYPE html>

<title>Reflective programming</title>

</head>

Reflective programming

</h1>

</header>

/* start https://en.wikipedia.org/ */

.mw-parser-output .hatnote{font-style:italic}.mw-parser-output div.hatnote{padding-left:1.6em;margin-bottom:0.5em}.mw-parser-output .hatnote i{font-style:normal}.mw-parser-output .hatnote+link+.hatnote{margin-top:-0.5em}@media print{body.ns-0 .mw-parser-output .hatnote{display:none!important}}

/* end https://en.wikipedia.org/ */

</style><div role="note" class="hatnote navigation-not-searchable">Not to be confused with <a href="Reflection_(computer_graphics)" title="Reflection (computer graphics)">Reflection (computer graphics)</a>.</div>

In <a href="Computer_science" title="Computer science">computer science</a>, reflective programming or reflection is the ability of a <a href="Process_(computing)" title="Process (computing)">process</a> to examine, <a href="Introspection_(computer_science)" class="mw-redirect" title="Introspection (computer science)">introspect</a>, and modify its own structure and behavior.<a href="#cite_note-1">[1]</a>

<div class="mw-heading mw-heading2"><h2 id="Historical_background">Historical background</h2></div>

The earliest computers were programmed in their native <a href="Assembly_language" title="Assembly language">assembly languages</a>, which were inherently reflective, as these original architectures could be programmed by defining instructions as data and using <a href="Self-modifying_code" title="Self-modifying code">self-modifying code</a>. As the bulk of programming moved to higher-level <a href="Compiled_languages" class="mw-redirect" title="Compiled languages">compiled languages</a> such as <a href="ALGOL" title="ALGOL">ALGOL</a>, <a href="COBOL" title="COBOL">COBOL</a>, <a href="Fortran" title="Fortran">Fortran</a>, <a href="Pascal_(programming_language)" title="Pascal (programming language)">Pascal</a>, and <a href="C_(programming_language)" title="C (programming language)">C</a>, this reflective ability largely disappeared until new programming languages with reflection built into their type systems appeared.

<a href="Brian_Cantwell_Smith" title="Brian Cantwell Smith">Brian Cantwell Smith</a>'s 1982 doctoral dissertation introduced the notion of computational reflection in procedural <a href="Programming_languages" class="mw-redirect" title="Programming languages">programming languages</a> and the notion of the <a href="Meta-circular_interpreter" class="mw-redirect" title="Meta-circular interpreter">meta-circular interpreter</a> as a component of 3-Lisp.<a href="#cite_note-2">[2]</a><a href="#cite_note-3">[3]</a>

Reflection helps programmers make generic software libraries to display data, process different formats of data, perform <a href="Serialization" title="Serialization">serialization</a> and deserialization of data for communication, or do bundling and unbundling of data for containers or bursts of communication.

Effective use of reflection almost always requires a plan: A design framework, encoding description, object library, a map of a database or entity relations.

Reflection makes a language more suited to network-oriented code. For example, it assists languages such as <a href="Java_(programming_language)" title="Java (programming language)">Java</a> to operate well in networks by enabling libraries for serialization, bundling and varying data formats. Languages without reflection such as <a href="C_(programming_language)" title="C (programming language)">C</a> are required to use auxiliary compilers for tasks like <a href="Abstract_Syntax_Notation" class="mw-redirect" title="Abstract Syntax Notation">Abstract Syntax Notation</a> to produce code for serialization and bundling.

Reflection can be used for observing and modifying program execution at <a href="Runtime_(program_lifecycle_phase)" class="mw-redirect" title="Runtime (program lifecycle phase)">runtime</a>. A reflection-oriented program component can monitor the execution of an enclosure of code and can modify itself according to a desired goal of that enclosure. This is typically accomplished by dynamically assigning program code at runtime.

In <a href="Object-oriented_programming" title="Object-oriented programming">object-oriented programming</a> languages such as <a href="Java_(programming_language)" title="Java (programming language)">Java</a>, reflection allows inspection of classes, interfaces, fields and methods at runtime without knowing the names of the interfaces, fields, methods at <a href="Compile_time" title="Compile time">compile time</a>. It also allows instantiation of new objects and invocation of methods.

Reflection is often used as part of <a href="Software_testing" title="Software testing">software testing</a>, such as for the runtime creation/instantiation of <a href="Mock_object" title="Mock object">mock objects</a>.

Reflection is also a key strategy for <a href="Metaprogramming" title="Metaprogramming">metaprogramming</a>.

In some object-oriented programming languages such as <a href="C_Sharp_(programming_language)" title="C Sharp (programming language)">C#</a> and <a href="Java_(programming_language)" title="Java (programming language)">Java</a>, reflection can be used to bypass <a href="Member_accessibility" class="mw-redirect" title="Member accessibility">member accessibility</a> rules. For C#-properties this can be achieved by writing directly onto the (usually invisible) backing field of a non-public property. It is also possible to find non-public methods of classes and types and manually invoke them. This works for project-internal files as well as external libraries such as <a href=".NET_Framework" title=".NET Framework">.NET</a>'s assemblies and Java's archives.

<div class="mw-heading mw-heading2"><h2 id="Implementation">Implementation</h2></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .ambox{border:1px solid #a2a9b1;border-left:10px solid #36c;background-color:#fbfbfb;box-sizing:border-box}.mw-parser-output .ambox+link+.ambox,.mw-parser-output .ambox+link+style+.ambox,.mw-parser-output .ambox+link+link+.ambox,.mw-parser-output .ambox+.mw-empty-elt+link+.ambox,.mw-parser-output .ambox+.mw-empty-elt+link+style+.ambox,.mw-parser-output .ambox+.mw-empty-elt+link+link+.ambox{margin-top:-1px}html body.mediawiki .mw-parser-output .ambox.mbox-small-left{margin:4px 1em 4px 0;overflow:hidden;width:238px;border-collapse:collapse;font-size:88%;line-height:1.25em}.mw-parser-output .ambox-speedy{border-left:10px solid #b32424;background-color:#fee7e6}.mw-parser-output .ambox-delete{border-left:10px solid #b32424}.mw-parser-output .ambox-content{border-left:10px solid #f28500}.mw-parser-output .ambox-style{border-left:10px solid #fc3}.mw-parser-output .ambox-move{border-left:10px solid #9932cc}.mw-parser-output .ambox-protection{border-left:10px solid #a2a9b1}.mw-parser-output .ambox .mbox-text{border:none;padding:0.25em 0.5em;width:100%}.mw-parser-output .ambox .mbox-image{border:none;padding:2px 0 2px 0.5em;text-align:center}.mw-parser-output .ambox .mbox-imageright{border:none;padding:2px 0.5em 2px 0;text-align:center}.mw-parser-output .ambox .mbox-empty-cell{border:none;padding:0;width:1px}.mw-parser-output .ambox .mbox-image-div{width:52px}@media(min-width:720px){.mw-parser-output .ambox{margin:0 10%}}@media print{body.ns-0 .mw-parser-output .ambox{display:none!important}}

/* end https://en.wikipedia.org/ */

</style>

A language that supports reflection provides a number of features available at runtime that would otherwise be difficult to accomplish in a lower-level language. Some of these features are the abilities to:

<ul><li>Discover and modify <a href="Source_code" title="Source code">source-code</a> constructions (such as code blocks, <a href="Class_(computer_science)" class="mw-redirect" title="Class (computer science)">classes</a>, methods, protocols, etc.) as <a href="First-class_object" class="mw-redirect" title="First-class object">first-class objects</a> at <a href="Runtime_(program_lifecycle_phase)" class="mw-redirect" title="Runtime (program lifecycle phase)">runtime</a>.</li>

<li>Convert a <a href="String_(computer_science)" title="String (computer science)">string</a> matching the symbolic name of a class or function into a reference to or invocation of that class or function.</li>

<li>Evaluate a string as if it were a source-code statement at runtime.</li>

<li>Create a new <a href="Interpreter_(computing)" title="Interpreter (computing)">interpreter</a> for the language's <a href="Bytecode" title="Bytecode">bytecode</a> to give a new meaning or purpose for a programming construct.</li></ul>

These features can be implemented in different ways. In <a href="MOO_(programming_language)" class="mw-redirect" title="MOO (programming language)">MOO</a>, reflection forms a natural part of everyday programming idiom. When verbs (methods) are called, various variables such as verb (the name of the verb being called) and this (the object on which the verb is called) are populated to give the context of the call. Security is typically managed by accessing the caller stack programmatically: Since callers() is a list of the methods by which the current verb was eventually called, performing tests on callers()[0] (the command invoked by the original user) allows the verb to protect itself against unauthorised use.

Compiled languages rely on their runtime system to provide information about the source code. A compiled <a href="Objective-C" title="Objective-C">Objective-C</a> executable, for example, records the names of all methods in a block of the executable, providing a table to correspond these with the underlying methods (or selectors for these methods) compiled into the program. In a compiled language that supports runtime creation of functions, such as <a href="Common_Lisp" title="Common Lisp">Common Lisp</a>, the runtime environment must include a compiler or an interpreter.

Reflection can be implemented for languages without built-in reflection by using a <a href="Program_transformation" title="Program transformation">program transformation</a> system to define automated source-code changes.

<div class="mw-heading mw-heading2"><h2 id="Security_considerations">Security considerations</h2></div>

Reflection may allow a user to create unexpected <a href="Control_flow" title="Control flow">control flow</a> paths through an application, potentially bypassing security measures. This may be exploited by attackers.<a href="#cite_note-4">[4]</a> Historical <a href="Vulnerability_(computing)" class="mw-redirect" title="Vulnerability (computing)">vulnerabilities</a> in Java caused by unsafe reflection allowed code retrieved from potentially untrusted remote machines to break out of the Java <a href="Sandbox_(computer_security)" title="Sandbox (computer security)">sandbox</a> security mechanism. A large scale study of 120 Java vulnerabilities in 2013 concluded that unsafe reflection is the most common vulnerability in Java, though not the most exploited.<a href="#cite_note-5">[5]</a>

<div class="mw-heading mw-heading2"><h2 id="Examples">Examples</h2></div>

The following code snippets create an <a href="Instance_(computer_science)" title="Instance (computer science)">instance</a> <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">foo</code> of <a href="Class_(computer_science)" class="mw-redirect" title="Class (computer science)">class</a> <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">Foo</code> and invoke its <a href="Method_(computer_science)" class="mw-redirect" title="Method (computer science)">method</a> <code class="mw-highlight mw-highlight-lang-text mw-content-ltr" style="" dir="ltr">PrintHello</code>. For each <a href="Programming_language" title="Programming language">programming language</a>, normal and reflection-based call sequences are shown.

<div class="mw-heading mw-heading3"><h3 id="Common_Lisp">Common Lisp</h3></div>

The following is an example in <a href="Common_Lisp" title="Common Lisp">Common Lisp</a> using the <a href="Common_Lisp_Object_System" title="Common Lisp Object System">Common Lisp Object System</a>:

<div class="mw-highlight mw-highlight-lang-lisp mw-content-ltr" dir="ltr"><pre>(defclass foo () ())

(defmethod print-hello ((f foo)) (format T "Hello from ~S~%" f))

;; Normal, without reflection

(let ((foo (make-instance 'foo)))

(print-hello foo))

;; With reflection to look up the class named "foo" and the method

;; named "print-hello" that specializes on "foo".

(let* ((foo-class (find-class (read-from-string "foo")))

(print-hello-method (find-method (symbol-function (read-from-string "print-hello"))

nil (list foo-class))))

(funcall (sb-mop:method-generic-function print-hello-method)

(make-instance foo-class)))

</pre></div>

The following is an example in <a href="C%2B%2B" title="C++">C++</a>.

<div class="mw-highlight mw-highlight-lang-cpp mw-content-ltr" dir="ltr"><pre>import std;

using std::string_view;

using std::meta::info;

using std::views::filter;

class Foo {

private:

// ...

public:

void printHello() const noexcept {

std::println("Hello, world!");

}

};

[[nodiscard]]

consteval bool isNonstaticMethod(info mem) noexcept {

return is_class_member(mem)

&& !is_static_member(mem)

&& is_function(mem);

}

[[nodiscard]]

consteval info findMethod(info ty, const char* name) {

constexpr auto ctx = std::meta::access_context::current();

for (info member : members_of(ty, ctx) | filter(isNonstaticMethod)) {

if (identifier_of(member) == name) {

return member;

}

return info{};

}

template <info Ty, auto Name>

constexpr auto createInvokerImpl = []{

using Type = [: Ty :];

static constexpr info M = findMethod(Ty, Name);

static_assert(parameters_of(M).size() == 0 && return_type_of(M) == ^^void);

return [](Type& instance) { instance.[: M :](); };

}();

[[nodiscard]]

consteval info createInvoker(info ty, string_view name) {

return substitute(^^createInvokerImpl, {

std::meta::reflect_constant(ty),

std::meta::reflect_constant_string(name)});

}

int main(int argc, char* argv[]) {

Foo foo;

// Without reflection

foo.printHello();

// With reflection

auto invokePrint = [: createInvoker(^^Foo, "printHello") :];

invokePrint(foo);

return 0;

}

</pre></div>

The following is an example in <a href="C_Sharp_(programming_language)" title="C Sharp (programming language)">C#</a>:

<div class="mw-highlight mw-highlight-lang-c# mw-content-ltr" dir="ltr"><pre>using System;

using System.Reflection;

class Foo {

// ...

public void PrintHello() {

Console.WriteLine("Hello, world!");

}

}

public class InvokeFooExample {

static void Main(string[] args) {

// Without reflection

foo.PrintHello();

// With reflection

Object foo = Activator.CreateInstance("complete.classpath.and.Foo");

MethodInfo method = foo.GetType().GetMethod("PrintHello");

method.Invoke(foo, null);

}

}

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Delphi,_Object_Pascal">Delphi, Object Pascal</h3></div>

This <a href="Delphi_(software)" title="Delphi (software)">Delphi</a> and <a href="Object_Pascal" title="Object Pascal">Object Pascal</a> example assumes that a <style data-mw-deduplicate="TemplateStyles:r886049734">

/* start https://en.wikipedia.org/ */

.mw-parser-output .monospaced{font-family:monospace,monospace}

/* end https://en.wikipedia.org/ */

</style>TFoo class has been declared in a unit called Unit1:

<div class="mw-highlight mw-highlight-lang-delphi mw-content-ltr" dir="ltr"><pre>uses RTTI, Unit1;

procedure WithoutReflection;

var

Foo: TFoo;

begin

Foo := TFoo.Create;

try

Foo.Hello;

finally

Foo.Free;

end;

end;

procedure WithReflection;

var

RttiContext: TRttiContext;

RttiType: TRttiInstanceType;

Foo: TObject;

begin

RttiType := RttiContext.FindType('Unit1.TFoo') as TRttiInstanceType;

Foo := RttiType.GetMethod('Create').Invoke(RttiType.MetaclassType, []).AsObject;

try

RttiType.GetMethod('Hello').Invoke(Foo, []);

finally

Foo.Free;

end;

end;

</pre></div>

The following is an example in eC:

<div class="mw-highlight mw-highlight-lang-ec mw-content-ltr" dir="ltr"><pre>// Without reflection

Foo foo { };

foo.hello();

// With reflection

Class fooClass = eSystem_FindClass(__thisModule, "Foo");

Instance foo = eInstance_New(fooClass);

Method m = eClass_FindMethod(fooClass, "hello", fooClass.module);

((void (*)())(void *)m.function)(foo);

</pre></div>

The following is an example in <a href="Go_(programming_language)" title="Go (programming language)">Go</a>:

<div class="mw-highlight mw-highlight-lang-go mw-content-ltr" dir="ltr"><pre>import "reflect"

// Without reflection

f := Foo{}

f.Hello()

// With reflection

fT := reflect.TypeOf(Foo{})

fV := reflect.New(fT)

m := fV.MethodByName("Hello")

if m.IsValid() {

m.Call(nil)

}

</pre></div>

The following is an example in <a href="Java_(programming_language)" title="Java (programming language)">Java</a>:

<div class="mw-highlight mw-highlight-lang-java mw-content-ltr" dir="ltr"><pre>import java.lang.reflect.Method;

class Foo {

// ...

public void printHello() {

System.out.println("Hello, world!");

}

}

public class InvokeFooExample {

public static void main(String[] args) {

// Without reflection

foo.printHello();

// With reflection

try {

Foo foo = Foo.class.getDeclaredConstructor().newInstance();

Method m = foo.getClass().getDeclaredMethod("printHello", new Class<?>[0]);

m.invoke(foo);

} catch (ReflectiveOperationException e) {

System.err.printf("An error occurred: %s%n", e.getMessage());

}

}

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="JavaScript/TypeScript">JavaScript/TypeScript</h3></div>

The following is an example in <a href="JavaScript" title="JavaScript">JavaScript</a>:

<div class="mw-highlight mw-highlight-lang-javascript mw-content-ltr" dir="ltr"><pre>// Without reflection

const foo = new Foo();

foo.hello();

// With reflection

const foo = Reflect.construct(Foo);

const hello = Reflect.get(foo, 'hello');

Reflect.apply(hello, foo, []);

// With eval

eval('new Foo().hello()');

</pre></div>

The following is the same example in <a href="TypeScript" title="TypeScript">TypeScript</a>:

<div class="mw-highlight mw-highlight-lang-typescript mw-content-ltr" dir="ltr"><pre>// Without reflection

const foo: Foo = new Foo();

foo.hello();

// With reflection

const foo: Foo = Reflect.construct(Foo);

const hello: (this: Foo) => void = Reflect.get(foo, 'hello') as (this: Foo) => void;

// With eval

eval('new Foo().hello()');

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Julia">Julia</h3></div>

The following is an example in <a href="Julia_(programming_language)" title="Julia (programming language)">Julia</a>:

<div class="mw-highlight mw-highlight-lang-julia-repl mw-content-ltr" dir="ltr"><pre>julia> struct Point

x::Int

y

end

# Inspection with reflection

julia> fieldnames(Point)

(:x, :y)

julia> fieldtypes(Point)

(Int64, Any)

julia> p = Point(3,4)

# Access with reflection

julia> getfield(p, :x)

3

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Objective-C">Objective-C</h3></div>

The following is an example in <a href="Objective-C" title="Objective-C">Objective-C</a>, implying either the <a href="OpenStep" title="OpenStep">OpenStep</a> or <a href="Foundation_Kit" title="Foundation Kit">Foundation Kit</a> framework is used:

<div class="mw-highlight mw-highlight-lang-objc mw-content-ltr" dir="ltr"><pre>// Foo class.

@interface Foo : NSObject

- (void)hello;

@end

// Sending "hello" to a Foo instance without reflection.

Foo *obj = [[Foo alloc] init];

[obj hello];

// Sending "hello" to a Foo instance with reflection.

id obj = [[NSClassFromString(@"Foo") alloc] init];

[obj performSelector: @selector(hello)];

</pre></div>

The following is an example in <a href="Perl" title="Perl">Perl</a>:

<div class="mw-highlight mw-highlight-lang-perl mw-content-ltr" dir="ltr"><pre># Without reflection

my $foo = Foo->new;

$foo->hello;

# or

Foo->new->hello;

# With reflection

my $class = "Foo"

my $constructor = "new";

my $method = "hello";

my $f = $class->$constructor;

$f->$method;

# or

$class->$constructor->$method;

# with eval

eval "new Foo->hello;";

</pre></div>

The following is an example in <a href="PHP" title="PHP">PHP</a>:<a href="#cite_note-6">[6]</a>

<div class="mw-highlight mw-highlight-lang-php mw-content-ltr" dir="ltr"><pre>// Without reflection

$foo = new Foo();

$foo->hello();

// With reflection, using Reflections API

$reflector = new ReflectionClass("Foo");

$foo = $reflector->newInstance();

$hello = $reflector->getMethod("hello");

$hello->invoke($foo);

</pre></div>

<div class="mw-heading mw-heading3"><h3 id="Python">Python</h3></div>

The following is an example in <a href="Python_(programming_language)" title="Python (programming language)">Python</a>:

<div class="mw-highlight mw-highlight-lang-python mw-content-ltr" dir="ltr"><pre>from typing import Any

class Foo:

# ...

def print_hello() -> None:

print("Hello, world!")

if __name__ == "__main__":

# Without reflection

obj: Foo = Foo()

obj.print_hello()

# With reflection

obj: Foo = globals()["Foo"]()

_: Any = getattr(obj, "print_hello")()

# With eval

eval("Foo().print_hello()")

</pre></div>

The following is an example in <a href="R_(programming_language)" title="R (programming language)">R</a>:

<div class="mw-highlight mw-highlight-lang-r mw-content-ltr" dir="ltr"><pre># Without reflection, assuming foo() returns an S3-type object that has method "hello"

obj <- foo()

hello(obj)

# With reflection

class_name <- "foo"

generic_having_foo_method <- "hello"

obj <- do.call(class_name, list())

do.call(generic_having_foo_method, alist(obj))

</pre></div>

The following is an example in <a href="Ruby_(programming_language)" title="Ruby (programming language)">Ruby</a>:

<div class="mw-highlight mw-highlight-lang-ruby mw-content-ltr" dir="ltr"><pre># Without reflection

obj = Foo.new

obj.hello

# With reflection

obj = Object.const_get("Foo").new

obj.send :hello

# With eval

eval "Foo.new.hello"

</pre></div>

<a href="Rust_(programming_language)" title="Rust (programming language)">Rust</a> does not have compile-time reflection in the standard library, but it is possible using some third-party libraries such as "<a rel="nofollow" class="external text" href="https://docs.rs/bevy_reflect/latest/bevy_reflect/">bevy_reflect</a>".

<div class="mw-highlight mw-highlight-lang-rust mw-content-ltr" dir="ltr"><pre>use std::any::TypeId;

use bevy_reflect::prelude::*;

use bevy_reflect::{

FunctionRegistry,

GetTypeRegistration,

Reflect,

ReflectFunction,

ReflectFunctionRegistry,

ReflectMut,

ReflectRef,

TypeRegistry

};

#[derive(Reflect)]

#[reflect(DoFoo)]

struct Foo {

// ...

}

impl Foo {

fn new() -> Self {

Foo {}

}

fn print_hello(&self) {

println!("Hello, world!");

}

}

#[reflect_trait]

trait DoFoo {

}

impl DoFoo for Foo {

self.print_hello();

}

}

fn main() {

// Without reflection

let foo: Foo = Foo::new();

foo.print_hello();

// With reflection

let mut registry: TypeRegistry = TypeRegistry::default();

registry.register::<Foo>();

registry.register_type_data::<Foo, ReflectFunctionRegistry>();

registry.register_type_data::<Foo, ReflectDoFoo>();

let reflect_foo: Box<dyn Reflect> = Box::new(foo);

// Version 1: call hello by trait

let trait_registration: &ReflectDoFoo = registry

.get_type_data::<ReflectDoFoo>(TypeId::of::<Foo>())

.expect("ReflectDoFoo not found for Foo");

let trait_object: &dyn DoFoo = trait_registration

.get(&*reflect_foo)

.expect("Failed to get DoFoo trait object");

trait_object.print_hello();

// Version 2: call hello by function name

let func_registry: &FunctionRegistry = registry

.get_type_data::<FunctionRegistry>(TypeId::of::<Foo>())

.expect("FunctionRegistry not found for Foo");

if let Some(dyn_func) = func_registry.get("print_hello") {

let result: Option<Box<dyn Reflect>> = dyn_func

.call(&*reflect_foo, Vec::<Box<dyn Reflect>>::new())

.ok();

if result.is_none() {

println!("Function called, no result returned (as expected for void return)");

}

} else {

println!("No function named hello found in FunctionRegistry");

}

}

</pre></div>

The following is an example using <a href="Xojo" title="Xojo">Xojo</a>:

<div class="mw-highlight mw-highlight-lang-vbnet mw-content-ltr" dir="ltr"><pre>' Without reflection

fooInstance.PrintHello

' With reflection

Dim classInfo As Introspection.Typeinfo = GetTypeInfo(Foo)

Dim constructors() As Introspection.ConstructorInfo = classInfo.GetConstructors

Dim fooInstance As Foo = constructors(0).Invoke

Dim methods() As Introspection.MethodInfo = classInfo.GetMethods

For Each m As Introspection.MethodInfo In methods

If m.Name = "PrintHello" Then

m.Invoke(fooInstance)

End If

Next

</pre></div>

<ul><li><a href="List_of_reflective_programming_languages_and_platforms" title="List of reflective programming languages and platforms">List of reflective programming languages and platforms</a></li>

<li><a href="Mirror_(programming)" title="Mirror (programming)">Mirror (programming)</a></li>

<li><a href="Programming_paradigm" title="Programming paradigm">Programming paradigms</a></li>

<li><a href="Self-hosting_(compilers)" title="Self-hosting (compilers)">Self-hosting (compilers)</a></li>

<li><a href="Self-modifying_code" title="Self-modifying code">Self-modifying code</a></li>

<li><a href="Type_introspection" title="Type introspection">Type introspection</a></li>

<li><a href="Typeof" title="Typeof">typeof</a></li></ul>

<div class="mw-heading mw-heading2"><h2 id="References">References</h2></div>

<div class="mw-heading mw-heading3"><h3 id="Citations">Citations</h3></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .reflist{margin-bottom:0.5em;list-style-type:decimal}@media screen{.mw-parser-output .reflist{font-size:90%}}.mw-parser-output .reflist .references{font-size:100%;margin-bottom:0;list-style-type:inherit}.mw-parser-output .reflist-columns-2{column-width:30em}.mw-parser-output .reflist-columns-3{column-width:25em}.mw-parser-output .reflist-columns{margin-top:0.3em}.mw-parser-output .reflist-columns ol{margin-top:0}.mw-parser-output .reflist-columns li{page-break-inside:avoid;break-inside:avoid-column}.mw-parser-output .reflist-upper-alpha{list-style-type:upper-alpha}.mw-parser-output .reflist-upper-roman{list-style-type:upper-roman}.mw-parser-output .reflist-lower-alpha{list-style-type:lower-alpha}.mw-parser-output .reflist-lower-greek{list-style-type:lower-greek}.mw-parser-output .reflist-lower-roman{list-style-type:lower-roman}

/* end https://en.wikipedia.org/ */

</style><div class="reflist">

/* start https://en.wikipedia.org/ */

.mw-parser-output cite.citation{font-style:inherit;word-wrap:break-word}.mw-parser-output .citation q{quotes:"\"""\"""'""'"}.mw-parser-output .citation:target{background-color:rgba(0,127,255,0.133)}.mw-parser-output .id-lock-free.id-lock-free a{background:url("./mw/Lock-green.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-limited.id-lock-limited a,.mw-parser-output .id-lock-registration.id-lock-registration a{background:url("./mw/Lock-gray-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .id-lock-subscription.id-lock-subscription a{background:url("./mw/Lock-red-alt-2.svg")right 0.1em center/9px no-repeat}.mw-parser-output .cs1-ws-icon a{background:url("./mw/Wikisource-logo.svg")right 0.1em center/12px no-repeat}body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-free a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-limited a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-registration a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .id-lock-subscription a,body:not(.skin-timeless):not(.skin-minerva) .mw-parser-output .cs1-ws-icon a{background-size:contain;padding:0 1em 0 0}.mw-parser-output .cs1-code{color:inherit;background:inherit;border:none;padding:inherit}.mw-parser-output .cs1-hidden-error{display:none;color:var(--color-error,#d33)}.mw-parser-output .cs1-visible-error{color:var(--color-error,#d33)}.mw-parser-output .cs1-maint{display:none;color:#085;margin-left:0.3em}.mw-parser-output .cs1-kern-left{padding-left:0.2em}.mw-parser-output .cs1-kern-right{padding-right:0.2em}.mw-parser-output .citation .mw-selflink{font-weight:inherit}@media screen{.mw-parser-output .cs1-format{font-size:95%}html.skin-theme-clientpref-night .mw-parser-output .cs1-maint{color:#18911f}}@media screen and (prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .cs1-maint{color:#18911f}}

/* end https://en.wikipedia.org/ */

</style><cite class="citation cs2"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20170821214626/http://www2.parc.com/csl/groups/sda/projects/reflection96/docs/malenfant/malenfant.pdf">A Tutorial on Behavioral Reflection and its Implementation by Jacques Malenfant et al.</a> (PDF), unknown, archived from <a rel="nofollow" class="external text" href="https://www2.parc.com/csl/groups/sda/projects/reflection96/docs/malenfant/malenfant.pdf">the original</a> (PDF) on 21 August 2017, retrieved 23 June 2019</cite>

</li>

<li id="cite_note-2"><a href="#cite_ref-2">^</a> Brian Cantwell Smith, <a rel="nofollow" class="external text" href="http://hdl.handle.net/1721.1/15961">Procedural Reflection in Programming Languages</a>, Department of Electrical Engineering and Computer Science, Massachusetts Institute of Technology, PhD dissertation, 1982.

</li>

<li id="cite_note-3"><a href="#cite_ref-3">^</a> Brian C. Smith. <a rel="nofollow" class="external text" href="http://publications.csail.mit.edu/lcs/specpub.php?id=840">Reflection and semantics in a procedural language</a> <a rel="nofollow" class="external text" href="https://web.archive.org/web/20151213034343/http://publications.csail.mit.edu/lcs/specpub.php?id=840">Archived</a> 2015-12-13 at the <a href="Wayback_Machine" title="Wayback Machine">Wayback Machine</a>. Technical Report MIT-LCS-TR-272, Massachusetts Institute of Technology, Cambridge, Massachusetts, January 1982.

</li>

<li id="cite_note-4"><a href="#cite_ref-4">^</a> <cite id="CITEREFBarrosJustMillsteinVines2015" class="citation report cs1">Barros, Paulo; Just, René; Millstein, Suzanne; Vines, Paul; Dietl, Werner; d'Amorim, Marcelo; Ernst, Michael D. (August 2015). <a rel="nofollow" class="external text" href="https://homes.cs.washington.edu/~mernst/pubs/implicit-control-flow-tr150801.pdf">Static Analysis of Implicit Control Flow: Resolving Java Reflection and Android Intents</a> (PDF) (Report). University of Washington. UW-CSE-15-08-01. Retrieved October 7, 2021.</cite>

</li>

<li id="cite_note-5"><a href="#cite_ref-5">^</a> <cite id="CITEREFEauvidoum,_Ieudisk_noise2021" class="citation magazine cs1">Eauvidoum, Ieu; disk noise (October 5, 2021). <a rel="nofollow" class="external text" href="http://phrack.org/issues/70/7.html#article">"Twenty years of Escaping the Java Sandbox"</a>. <a href="Phrack" title="Phrack">Phrack</a>. Vol. 10, no. 46. Retrieved October 7, 2021.</cite>

</li>

<li id="cite_note-6"><a href="#cite_ref-6">^</a> <cite class="citation web cs1"><a rel="nofollow" class="external text" href="https://www.php.net/manual/en/class.reflectionclass.php">"PHP: ReflectionClass - Manual"</a>. www.php.net.</cite>

</li>

</ol></div></div>

<div class="mw-heading mw-heading3"><h3 id="Sources">Sources</h3></div>

/* start https://en.wikipedia.org/ */

.mw-parser-output .refbegin{margin-bottom:0.5em}.mw-parser-output .refbegin-hanging-indents>ul{margin-left:0}.mw-parser-output .refbegin-hanging-indents>ul>li{margin-left:0;padding-left:3.2em;text-indent:-3.2em}.mw-parser-output .refbegin-hanging-indents ul,.mw-parser-output .refbegin-hanging-indents ul li{list-style:none}@media(max-width:720px){.mw-parser-output .refbegin-hanging-indents>ul>li{padding-left:1.6em;text-indent:-1.6em}}.mw-parser-output .refbegin-columns{margin-top:0.3em}.mw-parser-output .refbegin-columns ul{margin-top:0}.mw-parser-output .refbegin-columns li{page-break-inside:avoid;break-inside:avoid-column}@media screen{.mw-parser-output .refbegin{font-size:90%}}

/* end https://en.wikipedia.org/ */

</style><div class="refbegin" style="">

<ul><li>Jonathan M. Sobel and Daniel P. Friedman. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20100204091328/http://www.cs.indiana.edu/~jsobel/rop.html">An Introduction to Reflection-Oriented Programming</a> (1996), <a href="Indiana_University" title="Indiana University">Indiana University</a>.</li>

<li><a rel="nofollow" class="external text" href="https://www.codeproject.com/Articles/674455/Anti-Reflector-NET-Code-Protection">Anti-Reflection technique using C# and C++/CLI wrapper to prevent code thief</a></li></ul>

</div>

<div class="mw-heading mw-heading2"><h2 id="Further_reading">Further reading</h2></div>

<ul><li>Ira R. Forman and Nate Forman, Java Reflection in Action (2005), <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>1-932394-18-4</bdi></li>

<li>Ira R. Forman and Scott Danforth, Putting Metaclasses to Work (1999), <a href="ISBN_(identifier)" class="mw-redirect" title="ISBN (identifier)">ISBN</a> <bdi>0-201-43305-2</bdi></li></ul>

<div class="mw-heading mw-heading2"><h2 id="External_links">External links</h2></div>

<ul><li><a rel="nofollow" class="external text" href="https://www-master.ufr-info-p6.jussieu.fr/2007/Ajouts/Master_esj20_2007_2008/IMG/pdf/malenfant-ijcai95.pdf">Reflection in logic, functional and object-oriented programming: a short comparative study</a></li>

<li><a rel="nofollow" class="external text" href="https://web.archive.org/web/20100204091328/http://www.cs.indiana.edu/~jsobel/rop.html">An Introduction to Reflection-Oriented Programming</a></li>

<li><a rel="nofollow" class="external text" href="http://www.laputan.org/#Reflection">Brian Foote's pages on Reflection in Smalltalk</a></li>

<li><a rel="nofollow" class="external text" href="http://docs.oracle.com/javase/tutorial/reflect/index.html">Java Reflection API Tutorial</a> from Oracle</li></ul>

/* start https://en.wikipedia.org/ */

.mw-parser-output .hlist dl,.mw-parser-output .hlist ol,.mw-parser-output .hlist ul{margin:0;padding:0}.mw-parser-output .hlist dd,.mw-parser-output .hlist dt,.mw-parser-output .hlist li{margin:0;display:inline}.mw-parser-output .hlist.inline,.mw-parser-output .hlist.inline dl,.mw-parser-output .hlist.inline ol,.mw-parser-output .hlist.inline ul,.mw-parser-output .hlist dl dl,.mw-parser-output .hlist dl ol,.mw-parser-output .hlist dl ul,.mw-parser-output .hlist ol dl,.mw-parser-output .hlist ol ol,.mw-parser-output .hlist ol ul,.mw-parser-output .hlist ul dl,.mw-parser-output .hlist ul ol,.mw-parser-output .hlist ul ul{display:inline}.mw-parser-output .hlist .mw-empty-li{display:none}.mw-parser-output .hlist dt::after{content:": "}.mw-parser-output .hlist dd::after,.mw-parser-output .hlist li::after{content:" · ";font-weight:bold}.mw-parser-output .hlist dd:last-child::after,.mw-parser-output .hlist dt:last-child::after,.mw-parser-output .hlist li:last-child::after{content:none}.mw-parser-output .hlist dd dd:first-child::before,.mw-parser-output .hlist dd dt:first-child::before,.mw-parser-output .hlist dd li:first-child::before,.mw-parser-output .hlist dt dd:first-child::before,.mw-parser-output .hlist dt dt:first-child::before,.mw-parser-output .hlist dt li:first-child::before,.mw-parser-output .hlist li dd:first-child::before,.mw-parser-output .hlist li dt:first-child::before,.mw-parser-output .hlist li li:first-child::before{content:" (";font-weight:normal}.mw-parser-output .hlist dd dd:last-child::after,.mw-parser-output .hlist dd dt:last-child::after,.mw-parser-output .hlist dd li:last-child::after,.mw-parser-output .hlist dt dd:last-child::after,.mw-parser-output .hlist dt dt:last-child::after,.mw-parser-output .hlist dt li:last-child::after,.mw-parser-output .hlist li dd:last-child::after,.mw-parser-output .hlist li dt:last-child::after,.mw-parser-output .hlist li li:last-child::after{content:")";font-weight:normal}.mw-parser-output .hlist ol{counter-reset:listitem}.mw-parser-output .hlist ol>li{counter-increment:listitem}.mw-parser-output .hlist ol>li::before{content:" "counter(listitem)"\a0 "}.mw-parser-output .hlist dd ol>li:first-child::before,.mw-parser-output .hlist dt ol>li:first-child::before,.mw-parser-output .hlist li ol>li:first-child::before{content:" ("counter(listitem)"\a0 "}

/* end https://en.wikipedia.org/ */

</style><style data-mw-deduplicate="TemplateStyles:r1236075235">

/* start https://en.wikipedia.org/ */

.mw-parser-output .navbox{box-sizing:border-box;border:1px solid #a2a9b1;width:100%;clear:both;font-size:88%;text-align:center;padding:1px;margin:1em auto 0}.mw-parser-output .navbox .navbox{margin-top:0}.mw-parser-output .navbox+.navbox,.mw-parser-output .navbox+.navbox-styles+.navbox{margin-top:-1px}.mw-parser-output .navbox-inner,.mw-parser-output .navbox-subgroup{width:100%}.mw-parser-output .navbox-group,.mw-parser-output .navbox-title,.mw-parser-output .navbox-abovebelow{padding:0.25em 1em;line-height:1.5em;text-align:center}.mw-parser-output .navbox-group{white-space:nowrap;text-align:right}.mw-parser-output .navbox,.mw-parser-output .navbox-subgroup{background-color:#fdfdfd}.mw-parser-output .navbox-list{line-height:1.5em;border-color:#fdfdfd}.mw-parser-output .navbox-list-with-group{text-align:left;border-left-width:2px;border-left-style:solid}.mw-parser-output tr+tr>.navbox-abovebelow,.mw-parser-output tr+tr>.navbox-group,.mw-parser-output tr+tr>.navbox-image,.mw-parser-output tr+tr>.navbox-list{border-top:2px solid #fdfdfd}.mw-parser-output .navbox-title{background-color:#ccf}.mw-parser-output .navbox-abovebelow,.mw-parser-output .navbox-group,.mw-parser-output .navbox-subgroup .navbox-title{background-color:#ddf}.mw-parser-output .navbox-subgroup .navbox-group,.mw-parser-output .navbox-subgroup .navbox-abovebelow{background-color:#e6e6ff}.mw-parser-output .navbox-even{background-color:#f7f7f7}.mw-parser-output .navbox-odd{background-color:transparent}.mw-parser-output .navbox .hlist td dl,.mw-parser-output .navbox .hlist td ol,.mw-parser-output .navbox .hlist td ul,.mw-parser-output .navbox td.hlist dl,.mw-parser-output .navbox td.hlist ol,.mw-parser-output .navbox td.hlist ul{padding:0.125em 0}.mw-parser-output .navbox .navbar{display:block;font-size:100%}.mw-parser-output .navbox-title .navbar{float:left;text-align:left;margin-right:0.5em}body.skin--responsive .mw-parser-output .navbox-image img{max-width:none!important}@media print{body.ns-0 .mw-parser-output .navbox{display:none!important}}

/* end https://en.wikipedia.org/ */

</style></div><div role="navigation" class="navbox" aria-labelledby="Programming_paradigms_(Comparison_by_language)368" style="padding:3px"><table class="nowraplinks mw-collapsible autocollapse navbox-inner" style="border-spacing:0;background:transparent;color:inherit"><tbody><tr><th scope="col" class="navbox-title" colspan="2"><style data-mw-deduplicate="TemplateStyles:r1239400231">

/* start https://en.wikipedia.org/ */

.mw-parser-output .navbar{display:inline;font-size:88%;font-weight:normal}.mw-parser-output .navbar-collapse{float:left;text-align:left}.mw-parser-output .navbar-boxtext{word-spacing:0}.mw-parser-output .navbar ul{display:inline-block;white-space:nowrap;line-height:inherit}.mw-parser-output .navbar-brackets::before{margin-right:-0.125em;content:"[ "}.mw-parser-output .navbar-brackets::after{margin-left:-0.125em;content:" ]"}.mw-parser-output .navbar li{word-spacing:-0.125em}.mw-parser-output .navbar a>span,.mw-parser-output .navbar a>abbr{text-decoration:inherit}.mw-parser-output .navbar-mini abbr{font-variant:small-caps;border-bottom:none;text-decoration:none;cursor:inherit}.mw-parser-output .navbar-ct-full{font-size:114%;margin:0 7em}.mw-parser-output .navbar-ct-mini{font-size:114%;margin:0 4em}html.skin-theme-clientpref-night .mw-parser-output .navbar li a abbr{color:var(--color-base)!important}@media(prefers-color-scheme:dark){html.skin-theme-clientpref-os .mw-parser-output .navbar li a abbr{color:var(--color-base)!important}}@media print{.mw-parser-output .navbar{display:none!important}}

/* end https://en.wikipedia.org/ */

</style><div id="Programming_paradigms_(Comparison_by_language)368" style="font-size:114%;margin:0 4em"><a href="Programming_paradigm" title="Programming paradigm">Programming paradigms</a> (<a href="Comparison_of_multi-paradigm_programming_languages" title="Comparison of multi-paradigm programming languages">Comparison by language</a>)</div></th></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Imperative_programming" title="Imperative programming">Imperative</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em"></div><table class="nowraplinks navbox-subgroup" style="border-spacing:0"><tbody><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Structured_programming" title="Structured programming">Structured</a></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Jackson_structured_programming" title="Jackson structured programming">Jackson structures</a></li>

<li><a href="Block_(programming)" title="Block (programming)">Block-structured</a></li>

<li><a href="Modular_programming" title="Modular programming">Modular</a></li>

<li><a href="Non-structured_programming" title="Non-structured programming">Non-structured</a></li>

<li><a href="Procedural_programming" title="Procedural programming">Procedural</a></li>

<li><a href="Programming_in_the_large_and_programming_in_the_small" title="Programming in the large and programming in the small">Programming in the large and in the small</a></li>

<li><a href="Design_by_contract" title="Design by contract">Design by contract</a></li>

<li><a href="Invariant-based_programming" title="Invariant-based programming">Invariant-based</a></li>

<li><a href="Nested_function" title="Nested function">Nested function</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Object-oriented_programming" title="Object-oriented programming">Object-oriented</a> (<a href="Comparison_of_programming_languages_(object-oriented_programming)" title="Comparison of programming languages (object-oriented programming)">comparison</a>, <a href="List_of_object-oriented_programming_languages" title="List of object-oriented programming languages">list</a>)</th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Class-based_programming" title="Class-based programming">Class-based</a>, <a href="Prototype-based_programming" title="Prototype-based programming">Prototype-based</a>, <a href="Object-based_language" title="Object-based language">Object-based</a></li>

<li><a href="Agent-oriented_programming" title="Agent-oriented programming">Agent</a></li>

<li><a href="Immutable_object" title="Immutable object">Immutable object</a></li>

<li><a href="Persistent_programming_language" title="Persistent programming language">Persistent</a></li>

<li><a href="Uniform_function_call_syntax" title="Uniform function call syntax">Uniform function call syntax</a></li></ul>

</div></td></tr></tbody></table><div></div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Declarative_programming" title="Declarative programming">Declarative</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em"></div><table class="nowraplinks navbox-subgroup" style="border-spacing:0"><tbody><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Functional_programming" title="Functional programming">Functional</a> (<a href="Comparison_of_functional_programming_languages" title="Comparison of functional programming languages">comparison</a>)</th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Recursion_(computer_science)" title="Recursion (computer science)">Recursive</a></li>

<li><a href="Anonymous_function" title="Anonymous function">Anonymous function</a> (<a href="Partial_application" title="Partial application">Partial application</a>)</li>

<li><a href="Higher-order_programming" title="Higher-order programming">Higher-order</a></li>

<li><a href="Purely_functional_programming" title="Purely functional programming">Purely functional</a></li>

<li><a href="Total_functional_programming" title="Total functional programming">Total</a></li>

<li><a href="Strict_programming_language" title="Strict programming language">Strict</a></li>

<li><a href="Generalized_algebraic_data_type" title="Generalized algebraic data type">GADTs</a></li>

<li><a href="Dependent_type" title="Dependent type">Dependent types</a></li>

<li><a href="Functional_logic_programming" title="Functional logic programming">Functional logic</a></li>

<li><a href="Tacit_programming" title="Tacit programming">Point-free style</a></li>

<li><a href="Expression-oriented_programming_language" title="Expression-oriented programming language">Expression-oriented</a></li>

<li><a href="Applicative_programming_language" title="Applicative programming language">Applicative</a>, <a href="Concatenative_programming_language" title="Concatenative programming language">Concatenative</a></li>

<li><a href="Function-level_programming" title="Function-level programming">Function-level</a>, <a href="Value-level_programming" title="Value-level programming">Value-level</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Dataflow_programming" title="Dataflow programming">Dataflow</a></th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Flow-based_programming" title="Flow-based programming">Flow-based</a></li>

<li><a href="Reactive_programming" title="Reactive programming">Reactive</a> (<a href="Functional_reactive_programming" title="Functional reactive programming">Functional reactive</a>)</li>

<li><a href="Signal_programming" class="mw-redirect" title="Signal programming">Signals</a></li>

<li><a href="Stream_processing" title="Stream processing">Streams</a></li>

<li><a href="Synchronous_programming_language" title="Synchronous programming language">Synchronous</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Logic_programming" title="Logic programming">Logic</a></th><td class="navbox-list-with-group navbox-list navbox-odd" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Abductive_logic_programming" title="Abductive logic programming">Abductive logic</a></li>

<li><a href="Answer_set_programming" title="Answer set programming">Answer set</a></li>

<li><a href="Constraint_programming" title="Constraint programming">Constraint</a> (<a href="Constraint_logic_programming" title="Constraint logic programming">Constraint logic</a>)</li>

<li><a href="Inductive_logic_programming" title="Inductive logic programming">Inductive logic</a></li>

<li><a href="Nondeterministic_programming" title="Nondeterministic programming">Nondeterministic</a></li>

<li><a href="Ontology_language" title="Ontology language">Ontology</a></li>

<li><a href="Probabilistic_logic_programming" title="Probabilistic logic programming">Probabilistic logic</a></li>

<li><a href="Query_language" title="Query language">Query</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Domain-specific_language" title="Domain-specific language">DSL</a></th><td class="navbox-list-with-group navbox-list navbox-even" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Algebraic_modeling_language" title="Algebraic modeling language">Algebraic modeling</a></li>

<li><a href="Array_programming" title="Array programming">Array</a></li>

<li><a href="Automata-based_programming" title="Automata-based programming">Automata-based</a> (<a href="Action_language" title="Action language">Action</a>)</li>

<li><a href="Command_language" title="Command language">Command</a> (<a href="Spacecraft_command_language" title="Spacecraft command language">Spacecraft</a>)</li>

<li><a href="Differentiable_programming" title="Differentiable programming">Differentiable</a></li>

<li><a href="Grammar-oriented_programming" title="Grammar-oriented programming">Grammar-oriented</a></li>

<li><a href="Interface_description_language" title="Interface description language">Interface description</a></li>

<li><a href="Language-oriented_programming" title="Language-oriented programming">Language-oriented</a></li>

<li><a href="List_comprehension" title="List comprehension">List comprehension</a></li>

<li><a href="Modeling_language" title="Modeling language">Modeling</a></li>

<li><a href="Natural-language_programming" class="mw-redirect" title="Natural-language programming">Natural language</a></li>

<li><a href="Non-English-based_programming_languages" title="Non-English-based programming languages">Non-English-based</a></li>

<li><a href="Page_description_language" title="Page description language">Page description</a></li>

<li><a href="Pipeline_(software)" title="Pipeline (software)">Pipes</a> and <a href="Filter_(software)" title="Filter (software)">filters</a></li>

<li><a href="Probabilistic_programming" title="Probabilistic programming">Probabilistic</a></li>

<li><a href="Quantum_programming" title="Quantum programming">Quantum</a></li>

<li><a href="Scientific_programming_language" title="Scientific programming language">Scientific</a></li>

<li><a href="Scripting_language" title="Scripting language">Scripting</a></li>

<li><a href="Set_theoretic_programming" title="Set theoretic programming">Set-theoretic</a></li>

<li><a href="Simulation_language" title="Simulation language">Simulation</a></li>

<li><a href="Stack-oriented_programming" title="Stack-oriented programming">Stack-based</a></li>

<li><a href="System_programming_language" title="System programming language">System</a></li>

<li><a href="Tactile_programming_language" title="Tactile programming language">Tactile</a></li>

<li><a href="Template_processor" title="Template processor">Templating</a></li>

<li><a href="Transformation_language" title="Transformation language">Transformation</a> (<a href="Graph_rewriting" title="Graph rewriting">Graph rewriting</a>, <a href="Production_system_(computer_science)" title="Production system (computer science)">Production</a>, <a href="Pattern_matching" title="Pattern matching">Pattern</a>)</li>

<li><a href="Visual_programming_language" title="Visual programming language">Visual</a></li></ul>

</div></td></tr></tbody></table><div></div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Concurrent_computing" title="Concurrent computing">Concurrent</a>, <a href="Distributed_computing" title="Distributed computing">distributed</a>, <a href="Parallel_computing" title="Parallel computing">parallel</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Actor_model" title="Actor model">Actor-based</a></li>

<li><a href="Automatic_mutual_exclusion" title="Automatic mutual exclusion">Automatic mutual exclusion</a></li>

<li><a href="Choreographic_programming" title="Choreographic programming">Choreographic programming</a></li>

<li><a href="Concurrent_logic_programming" title="Concurrent logic programming">Concurrent logic</a> (<a href="Concurrent_constraint_logic_programming" title="Concurrent constraint logic programming">Concurrent constraint logic</a>)</li>

<li><a href="Concurrent_object-oriented_programming" title="Concurrent object-oriented programming">Concurrent OO</a></li>

<li><a href="Macroprogramming" title="Macroprogramming">Macroprogramming</a></li>

<li><a href="Multitier_programming" title="Multitier programming">Multitier programming</a></li>

<li><a href="Organic_computing" title="Organic computing">Organic computing</a></li>

<li><a href="Parallel_programming_model" title="Parallel programming model">Parallel programming models</a></li>

<li><a href="Partitioned_global_address_space" title="Partitioned global address space">Partitioned global address space</a></li>

<li><a href="Process-oriented_programming" title="Process-oriented programming">Process-oriented</a></li>

<li><a href="Relativistic_programming" title="Relativistic programming">Relativistic programming</a></li>

<li><a href="Service-oriented_programming" title="Service-oriented programming">Service-oriented</a></li>

<li><a href="Structured_concurrency" title="Structured concurrency">Structured concurrency</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Metaprogramming" title="Metaprogramming">Metaprogramming</a></th><td class="navbox-list-with-group navbox-list navbox-even hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Attribute-oriented_programming" title="Attribute-oriented programming">Attribute-oriented</a></li>

<li><a href="Automatic_programming" title="Automatic programming">Automatic</a> (<a href="Inductive_programming" title="Inductive programming">Inductive</a>)</li>

<li><a href="Dynamic_programming_language" title="Dynamic programming language">Dynamic</a></li>

<li><a href="Extensible_programming" title="Extensible programming">Extensible</a></li>

<li><a href="Generic_programming" title="Generic programming">Generic</a></li>

<li><a href="Homoiconicity" title="Homoiconicity">Homoiconicity</a></li>

<li><a href="Interactive_programming" title="Interactive programming">Interactive</a></li>

<li><a href="Macro_(computer_science)" title="Macro (computer science)">Macro</a> (<a href="Hygienic_macro" title="Hygienic macro">Hygienic</a>)</li>

<li><a href="Metalinguistic_abstraction" title="Metalinguistic abstraction">Metalinguistic abstraction</a></li>

<li><a href="Multi-stage_programming" title="Multi-stage programming">Multi-stage</a></li>

<li><a href="Program_synthesis" title="Program synthesis">Program synthesis</a> (<a href="Bayesian_program_synthesis" title="Bayesian program synthesis">Bayesian</a>, <a href="Inferential_programming" title="Inferential programming">Inferential</a>, <a href="Programming_by_demonstration" title="Programming by demonstration">by demonstration</a>, <a href="Programming_by_example" title="Programming by example">by example</a>)</li>

<li><a href="Self-modifying_code" title="Self-modifying code">Self-modifying code</a></li>

<li><a href="Symbolic_programming" title="Symbolic programming">Symbolic</a></li>

<li><a href="Template_metaprogramming" title="Template metaprogramming">Template</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Separation_of_concerns" title="Separation of concerns">Separation of concerns</a></th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Aspect-oriented_programming" title="Aspect-oriented programming">Aspects</a></li>

<li><a href="Component-based_software_engineering" title="Component-based software engineering">Components</a></li>

<li><a href="Data-driven_programming" title="Data-driven programming">Data-driven</a></li>

<li><a href="Data-oriented_design" title="Data-oriented design">Data-oriented</a></li>

<li><a href="Event-driven_programming" title="Event-driven programming">Event-driven</a></li>

<li><a href="Feature-oriented_programming" title="Feature-oriented programming">Features</a></li>

<li><a href="Literate_programming" title="Literate programming">Literate</a></li>

<li><a href="Role-oriented_programming" title="Role-oriented programming">Roles</a></li>

<li><a href="Subject-oriented_programming" title="Subject-oriented programming">Subjects</a></li></ul>

</div></td></tr></tbody></table></div>

<div class="navbox-styles"></div><div role="navigation" class="navbox" aria-labelledby="Types_of_programming_languages107" style="padding:3px"><table class="nowraplinks mw-collapsible autocollapse navbox-inner" style="border-spacing:0;background:transparent;color:inherit"><tbody><tr><th scope="col" class="navbox-title" colspan="2"><div id="Types_of_programming_languages107" style="font-size:114%;margin:0 4em"><a href="Programming_paradigm" title="Programming paradigm">Types of programming languages</a></div></th></tr><tr><th scope="row" class="navbox-group" style="width:1%">Level</th><td class="navbox-list-with-group navbox-list navbox-odd hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="Machine_code" title="Machine code">Machine</a></li>

<li><a href="Assembly_language" title="Assembly language">Assembly</a></li>

<li><a href="Compiled_language" title="Compiled language">Compiled</a></li>

<li><a href="Interpreted_language" class="mw-redirect" title="Interpreted language">Interpreted</a></li></ul>

<ul><li><a href="Low-level_programming_language" title="Low-level programming language">Low-level</a></li>

<li><a href="High-level_programming_language" title="High-level programming language">High-level</a></li>

<li><a href="Very_high-level_programming_language" title="Very high-level programming language">Very high-level</a></li>

<li><a href="Esoteric_programming_language" title="Esoteric programming language">Esoteric</a></li></ul>

</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="Programming_language_generations" title="Programming language generations">Generation</a></th><td class="navbox-list-with-group navbox-list navbox-even hlist" style="width:100%;padding:0"><div style="padding:0 0.25em">

<ul><li><a href="First-generation_programming_language" title="First-generation programming language">First</a></li>

<li><a href="Second-generation_programming_language" title="Second-generation programming language">Second</a></li>

<li><a href="Third-generation_programming_language" title="Third-generation programming language">Third</a></li>

<li><a href="Fourth-generation_programming_language" title="Fourth-generation programming language">Fourth</a></li>

<li><a href="Fifth-generation_programming_language" title="Fifth-generation programming language">Fifth</a></li></ul>

</div></td></tr></tbody></table></div></div><div><div class="zim-footer">

This article is issued from <a class="external text" title="Last edited on 2025-08-06" href="https://en.wikipedia.org/wiki/?title=Reflective_programming&oldid=1304557821">Wikipedia</a>. The text is available under <a class="external text" href="https://creativecommons.org/licenses/by-sa/4.0/deed.en">Creative Commons Attribution-Share Alike 4.0</a> unless otherwise noted. Additional terms may apply for the media files.

</div>

</div></div>

</div>

</main>

</div>

</body></html>